/**
 * 用户信息API封装模块
 * @author HalRui
 * @version 1.0.0
 * @description 封装用户相关的数据库操作API，提供用户注册、登录、信息更新等功能
 * @date 2025年9月27日
 */

const userinfosModel = require('../models/userinfos-model');
const connectionPool = require('../utils/connection-pool');
const bcrypt = require('bcryptjs');

module.exports = {
    /**
     * @description : 验证邮箱有没有被注册过
     * @param value {String} : 传递的参数是 邮箱地址
     * @returns {Object} : 返回包含success和message的对象
     * */
    verifyEmail : async function (value) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const isUnique = await userinfosModel.isFieldUnique("email", value);
        return {
            success: isUnique,
            message: isUnique ? '邮箱可以使用' : '邮箱已被注册'
        };
    },

    /**
     * @description : 验证用户名有没有被注册过
     * @param value {String} : 传递的参数是 用户名
     * @returns {Object} : 返回包含success和message的对象
     * */
    verifyUsername : async function (value) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const isUnique = await userinfosModel.isFieldUnique("username", value);
        return {
            success: isUnique,
            message: isUnique ? '用户名可以使用' : '用户名已被注册'
        };
    },

    /**
     * @description : 验证手机号有没有被注册过
     * @param value {String} : 传递的参数是 手机号
     * @returns {Object} : 返回包含success和message的对象
     * */
    verifyPhone : async function (value) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const isUnique = await userinfosModel.isFieldUnique("phone", value);
        return {
            success: isUnique,
            message: isUnique ? '手机号可以使用' : '手机号已被注册'
        };
    },

    /**
     * @description : 创建新用户 - 使用封装的createUser方法，支持完整用户数据
     * @param userData {Object} : 用户数据对象，包含所有用户字段
     * @returns {Object} : 包含success和message的对象
     * */
    saveUserInfo :  async function (userData) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const result = await userinfosModel.createUser(userData);
        
        if (result.success) {
            return {
                success: true,
                message : result.user.isSafeJSON()
            }
        } else {
            return {
                success: false,
                message : result.error
            }
        }
    },

    /**
     * @description : 验证用户登录 - 使用封装的密码验证
     * @param email {String} : 用户邮箱
     * @param password {String} : 用户密码
     * @returns {Object} : 包含success和message的对象
     * */
    selectUser : async function (email,password) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const user = await userinfosModel.validatePassword(email, password);
        
        if (!user) {
            return {
                success: false,
                message: '邮箱或密码错误'
            };
        }

        return {
            success: true,
            message: {
                id : user._id,
                userId : user.userId,  // 添加数字类型的userId字段
                email : user.email,
                avatar : user.avatar
            }
        };
    },

    /**
     * @description : 根据邮箱查找用户
     * @param email {String} : 用户邮箱
     * @returns {Object} : 包含success和message的对象
     * */
    findUserByEmail : async function (email) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const user = await userinfosModel.findByEmail(email);

        const result = {
            "email": user.email,
            "userId": user.userId
        }

        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }
        
        return {
            success: true,
            message: result
        };
    },

    /**
     * @description : 更新用户最后登录时间
     * @param userId {String} : 用户ID
     * @returns {Object} : 包含success和message的对象
     * */
    updateLastLogin : async function (userId) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const result = await userinfosModel.updateLastLogin(userId);
        if (!result) {
            return {
                success: false,
                message: '用户不存在或更新失败'
            };
        }
        
        return {
            success: true,
            message: result
        };
    },

    /**
     * @description : 封禁用户
     * @param userId {String} : 用户ID
     * @returns {Object} : 包含success和message的对象
     * */
    banUser : async function (userId) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const result = await userinfosModel.banUser(userId);
        if (!result) {
            return {
                success: false,
                message: '用户不存在或封禁失败'
            };
        }
        
        return {
            success: true,
            message: result
        };
    },

    /**
     * @description : 解封用户
     * @param userId {String} : 用户ID
     * @returns {Object} : 包含success和message的对象
     * */
    unbanUser : async function (userId) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const result = await userinfosModel.unbanUser(userId);
        if (!result) {
            return {
                success: false,
                message: '用户不存在或解封失败'
            };
        }
        
        return {
            success: true,
            message: result
        };
    },

    /**
     * @description : 更新用户信息
     * @param userId {String} : 用户ID
     * @param updateData {Object} : 更新的数据对象
     * @returns {Object} : 包含success和message的对象
     * */
    updateUserInfo : async function (userId, updateData) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const result = await userinfosModel.updateUserInfo(userId, updateData);
        if (!result) {
            return {
                success: false,
                message: '用户不存在或更新失败'
            };
        }
        
        return {
            success: true,
            message: result
        };
    },

    /**
     * @description : 更改用户密码
     * @param userId {String} : 用户ID
     * @param newPassword {String} : 新密码
     * @returns {Object} : 包含success和message的对象
     * */
    changePassword : async function (userId, newPassword) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const user = await userinfosModel.findOne({userId});
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }

        const result = await user.changePassword(newPassword);
        return {
            success: result,
            message: result ? '密码修改成功' : '密码修改失败'
        };
    },
    /**
     * @description : 修改头像信息
     * @param userId {String} : 用户ID
     * @param filePath {String} : 新头像的路径
     * @returns {Object} : 包含success和message的对象
     * */
    changeAvatar : async function (userId, filePath) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }

        const user = await userinfosModel.findOne({userId});
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }

        const result = await user.changeAvatar(filePath);
        return {
            success: result,
            message: result ? '密码修改成功' : '密码修改失败'
        };
    },

    /**
     * @description : 获取用户基本信息（安全格式）
     * @param userId {String} : 用户ID
     * @returns {Object} : 包含success和message的对象
     * */
    getUserBasicInfo : async function (userId) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const user = await userinfosModel.findOne({userId});
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }
        
        return {
            success: true,
            message: user.isSafeJSON()
        };
    },

    /**
     *
     *
     *
     *
     * */
    findByUserId : async function(userId){
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }

        const user = await userinfosModel.findOne({userId});

        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }

        return {
            success: true,
            message: user.isSafeJSON()
        };
    },




    /**
     * @description : 检查用户状态
     * @param userId {String} : 用户ID
     * @returns {Object} : 包含success和message的对象
     * */
    checkUserStatus : async function (userId) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const user = await userinfosModel.findById(userId);
        if (!user) {
            return {
                success: true,
                message: { exists: false }
            };
        }
        
        return {
            success: true,
            message: {
                exists: true,
                isActive: user.isActive(),
                isBanned: user.isBanned(),
                status: user.status
            }
        };
    },

    /**
     * @description : 更新用户资料
     * @param userId {String} : 用户ID
     * @param updateData {Object} : 要更新的用户资料数据
     * @returns {Object} : 包含success和message的对象
     * */
    updateUserProfile : async function (userId, updateData) {
        // 确保连接池已连接
        const status = connectionPool.getConnectionStatus();
        if (!status.mongodb.connected) {
            return {
                success: false,
                message: 'MongoDB 未连接'
            };
        }
        
        const user = await userinfosModel.findById(userId);
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }
        
        try {
            const updatedUser = await user.updateProfile(updateData);
            return {
                success: true,
                message: updatedUser.isSafeJSON()
            };
        } catch (error) {
            return {
                success: false,
                message: '更新用户资料失败: ' + error.message
            };
        }
    }
}